///*
// * Copyright 1999-2008 Sun Microsystems, Inc.  All Rights Reserved.
// * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
// *
// * This code is free software; you can redistribute it and/or modify it
// * under the terms of the GNU General Public License version 2 only, as
// * published by the Free Software Foundation.  Sun designates this
// * particular file as subject to the "Classpath" exception as provided
// * by Sun in the LICENSE file that accompanied this code.
// *
// * This code is distributed in the hope that it will be useful, but WITHOUT
// * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
// * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
// * version 2 for more details (a copy is included in the LICENSE file that
// * accompanied this code).
// *
// * You should have received a copy of the GNU General Public License version
// * 2 along with this work; if not, write to the Free Software Foundation,
// * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
// *
// * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
// * CA 95054 USA or visit www.sun.com if you need additional information or
// * have any questions.
// */
//
//package com.sun.tools.javac.code;
//
//import com.sun.tools.javac.util.*;
//import com.sun.tools.javac.code.Symbol.*;
//
//import javax.lang.model.type.*;
//
//import static com.sun.tools.javac.code.Flags.*;
//import static com.sun.tools.javac.code.Kinds.*;
//import static com.sun.tools.javac.code.BoundKind.*;
//import static com.sun.tools.javac.code.TypeTags.*;
//
///** This class represents Java types. The class itself defines the behavior of
// *  the following types:
// *  <pre>
// *  base types (tags: BYTE, CHAR, SHORT, INT, LONG, FLOAT, DOUBLE, BOOLEAN),
// *  type `void' (tag: VOID),
// *  the bottom type (tag: BOT),
// *  the missing type (tag: NONE).
// *  </pre>
// *  <p>The behavior of the following types is defined in subclasses, which are
// *  all static inner classes of this class:
// *  <pre>
// *  class types (tag: CLASS, class: ClassType),
// *  array types (tag: ARRAY, class: ArrayType),
// *  method types (tag: METHOD, class: MethodType),
// *  package types (tag: PACKAGE, class: PackageType),
// *  type variables (tag: TYPEVAR, class: TypeVar),
// *  type arguments (tag: WILDCARD, class: WildcardType),
// *  polymorphic types (tag: FORALL, class: ForAll),
// *  the error type (tag: ERROR, class: ErrorType).
// *  </pre>
// *
// *  <p><b>This is NOT part of any API supported by Sun Microsystems.  If
// *  you write code that depends on this, you do so at your own risk.
// *  This code and its internal interfaces are subject to change or
// *  deletion without notice.</b>
// *
// *  @see TypeTags
// */
//public class Type implements PrimitiveType {
//
//    /** Constant type: no type at all. */
//    public static final JCNoType noType = new JCNoType(NONE);
//
//    /** If this switch is turned on, the names of type variables
//     *  and anonymous classes are printed with hashcodes appended.
//     */
//    public static boolean moreInfo = false;
//
//    /** The tag of this type.
//     *
//     *  @see TypeTags
//     */
//    public int tag;
//
//    /** The defining class / interface / package / type variable
//     */
//    public TypeSymbol tsym;
//
//    /**
//     * The constant value of this type, null if this type does not
//     * have a constant value attribute. Only primitive types and
//     * strings (ClassType) can have a constant value attribute.
//     * @return the constant value attribute of this type
//     */
//    public Object constValue() {
//        return null;
//    }
//
//    public <R,S> R accept(Type.Visitor<R,S> v, S s) { return v.visitType(this, s); }
//
//    /** Define a type given its tag and type symbol
//     */
//    public Type(int tag, TypeSymbol tsym) {
//        this.tag = tag;
//        this.tsym = tsym;
//    }
//
//    /** An abstract class for mappings from types to types
//     */
//    public static abstract class Mapping {
//        private String name;
//        public Mapping(String name) {
//            this.name = name;
//        }
//        public abstract Type apply(Type t);
//        public String toString() {
//            return name;
//        }
//    }
//
//    /** map a type function over all immediate descendants of this type
//     */
//    public Type map(Mapping f) {
//        return this;
//    }
//
//    /** map a type function over a list of types
//     */
//    public static List<Type> map(List<Type> ts, Mapping f) {
//        if (ts.nonEmpty()) {
//            List<Type> tail1 = map(ts.tail, f);
//            Type t = f.apply(ts.head);
//            if (tail1 != ts.tail || t != ts.head)
//                return tail1.prepend(t);
//        }
//        return ts;
//    }
//
//    /** Define a constant type, of the same kind as this type
//     *  and with given constant value
//     */
//    public Type constType(Object constValue) {
//        final Object value = constValue;
//        assert tag <= BOOLEAN;
//        return new Type(tag, tsym) {
//                @Override
//                public Object constValue() {
//                    return value;
//                }
//                @Override
//                public Type baseType() {
//                    return tsym.type;
//                }
//            };
//    }
//
//    /**
//     * If this is a constant type, return its underlying type.
//     * Otherwise, return the type itself.
//     */
//    public Type baseType() {
//        return this;
//    }
//
//    /** Return the base types of a list of types.
//     */
//    public static List<Type> baseTypes(List<Type> ts) {
//        if (ts.nonEmpty()) {
//            Type t = ts.head.baseType();
//            List<Type> baseTypes = baseTypes(ts.tail);
//            if (t != ts.head || baseTypes != ts.tail)
//                return baseTypes.prepend(t);
//        }
//        return ts;
//    }
//
//    /** The Java source which this type represents.
//     */
//    public String toString() {
//        String s = (tsym == null || tsym.name == null)
//            ? "<none>"
//            : tsym.name.toString();
//        if (moreInfo && tag == TYPEVAR) s = s + hashCode();
//        return s;
//    }
//
//    /**
//     * The Java source which this type list represents.  A List is
//     * represented as a comma-spearated listing of the elements in
//     * that list.
//     */
//    public static String toString(List<Type> ts) {
//        if (ts.isEmpty()) {
//            return "";
//        } else {
//            StringBuffer buf = new StringBuffer();
//            buf.append(ts.head.toString());
//            for (List<Type> l = ts.tail; l.nonEmpty(); l = l.tail)
//                buf.append(",").append(l.head.toString());
//            return buf.toString();
//        }
//    }
//
//    /**
//     * The constant value of this type, converted to String
//     */
//    public String stringValue() {
//        assert constValue() != null;
//        if (tag == BOOLEAN)
//            return ((Integer) constValue()).intValue() == 0 ? "false" : "true";
//        else if (tag == CHAR)
//            return String.valueOf((char) ((Integer) constValue()).intValue());
//        else
//            return constValue().toString();
//    }
//
//    /**
//     * This method is analogous to isSameType, but weaker, since we
//     * never complete classes. Where isSameType would complete a
//     * class, equals assumes that the two types are different.
//     */
//    public boolean equals(Object t) {
//        return super.equals(t);
//    }
//
//    public int hashCode() {
//        return super.hashCode();
//    }
//
//    /** Is this a constant type whose value is false?
//     */
//    public boolean isFalse() {
//        return
//            tag == BOOLEAN &&
//            constValue() != null &&
//            ((Integer)constValue()).intValue() == 0;
//    }
//
//    /** Is this a constant type whose value is true?
//     */
//    public boolean isTrue() {
//        return
//            tag == BOOLEAN &&
//            constValue() != null &&
//            ((Integer)constValue()).intValue() != 0;
//    }
//
//    public String argtypes(boolean varargs) {
//        List<Type> args = getParameterTypes();
//        if (!varargs) return args.toString();
//        StringBuffer buf = new StringBuffer();
//        while (args.tail.nonEmpty()) {
//            buf.append(args.head);
//            args = args.tail;
//            buf.append(',');
//        }
//        if (args.head.tag == ARRAY) {
//            buf.append(((ArrayType)args.head).elemtype);
//            buf.append("...");
//        } else {
//            buf.append(args.head);
//        }
//        return buf.toString();
//    }
//
//    /** Access methods.
//     */
//    public List<Type>        getTypeArguments()  { return List.nil(); }
//    public Type              getEnclosingType() { return null; }
//    public List<Type>        getParameterTypes() { return List.nil(); }
//    public Type              getReturnType()     { return null; }
//    public List<Type>        getThrownTypes()    { return List.nil(); }
//    public Type              getUpperBound()     { return null; }
//    public Type              getLowerBound()     { return null; }
//
//    public void setThrown(List<Type> ts) {
//        throw new AssertionError();
//    }
//
//    /** Navigation methods, these will work for classes, type variables,
//     *  foralls, but will return null for arrays and methods.
//     */
//
//   /** Return all parameters of this type and all its outer types in order
//    *  outer (first) to inner (last).
//    */
//    public List<Type> allparams() { return List.nil(); }
//
//    /** Does this type contain "error" elements?
//     */
//    public boolean isErroneous() {
//        return false;
//    }
//
//    public static boolean isErroneous(List<Type> ts) {
//        for (List<Type> l = ts; l.nonEmpty(); l = l.tail)
//            if (l.head.isErroneous()) return true;
//        return false;
//    }
//
//    /** Is this type parameterized?
//     *  A class type is parameterized if it has some parameters.
//     *  An array type is parameterized if its element type is parameterized.
//     *  All other types are not parameterized.
//     */
//    public boolean isParameterized() {
//        return false;
//    }
//
//    /** Is this type a raw type?
//     *  A class type is a raw type if it misses some of its parameters.
//     *  An array type is a raw type if its element type is raw.
//     *  All other types are not raw.
//     *  Type validation will ensure that the only raw types
//     *  in a program are types that miss all their type variables.
//     */
//    public boolean isRaw() {
//        return false;
//    }
//
//    public boolean isCompound() {
//        return tsym.completer == null
//            // Compound types can't have a completer.  Calling
//            // flags() will complete the symbol causing the
//            // compiler to load classes unnecessarily.  This led
//            // to regression 6180021.
//            && (tsym.flags() & COMPOUND) != 0;
//    }
//
//    public boolean isInterface() {
//        return (tsym.flags() & INTERFACE) != 0;
//    }
//
//    public boolean isPrimitive() {
//        return tag < VOID;
//    }
//
//    /**
//     * Does this type contain occurrences of type t?
//     */
//    public boolean contains(Type t) {
//        return t == this;
//    }
//
//    public static boolean contains(List<Type> ts, Type t) {
//        for (List<Type> l = ts;
//             l.tail != null /*inlined: l.nonEmpty()*/;
//             l = l.tail)
//            if (l.head.contains(t)) return true;
//        return false;
//    }
//
//    /** Does this type contain an occurrence of some type in `elems'?
//     */
//    public boolean containsSome(List<Type> ts) {
//        for (List<Type> l = ts; l.nonEmpty(); l = l.tail)
//            if (this.contains(ts.head)) return true;
//        return false;
//    }
//
//    public boolean isSuperBound() { return false; }
//    public boolean isExtendsBound() { return false; }
//    public boolean isUnbound() { return false; }
//    public Type withTypeVar(Type t) { return this; }
//
//    /** The underlying method type of this type.
//     */
//    public MethodType asMethodType() { throw new AssertionError(); }
//
//    /** Complete loading all classes in this type.
//     */
//    public void complete() {}
//
//    public Object clone() {
//        try {
//            return super.clone();
//        } catch (CloneNotSupportedException e) {
//            throw new AssertionError(e);
//        }
//    }
//
//    public TypeSymbol asElement() {
//        return tsym;
//    }
//
//    public TypeKind getKind() {
//        switch (tag) {
//        case BYTE:      return TypeKind.BYTE;
//        case CHAR:      return TypeKind.CHAR;
//        case SHORT:     return TypeKind.SHORT;
//        case INT:       return TypeKind.INT;
//        case LONG:      return TypeKind.LONG;
//        case FLOAT:     return TypeKind.FLOAT;
//        case DOUBLE:    return TypeKind.DOUBLE;
//        case BOOLEAN:   return TypeKind.BOOLEAN;
//        case VOID:      return TypeKind.VOID;
//        case BOT:       return TypeKind.NULL;
//        case NONE:      return TypeKind.NONE;
//        default:        return TypeKind.OTHER;
//        }
//    }
//
//    public <R, P> R accept(TypeVisitor<R, P> v, P p) {
//        if (isPrimitive())
//            return v.visitPrimitive(this, p);
//        else
//            throw new AssertionError();
//    }
//
//    public static class WildcardType extends Type
//            implements javax.lang.model.type.WildcardType {
//
//        public Type type;
//        public BoundKind kind;
//        public TypeVar bound;
//
//        @Override
//        public <R,S> R accept(Type.Visitor<R,S> v, S s) {
//            return v.visitWildcardType(this, s);
//        }
//
//        public WildcardType(Type type, BoundKind kind, TypeSymbol tsym) {
//            super(WILDCARD, tsym);
//            assert(type != null);
//            this.kind = kind;
//            this.type = type;
//        }
//        public WildcardType(WildcardType t, TypeVar bound) {
//            this(t.type, t.kind, t.tsym, bound);
//        }
//
//        public WildcardType(Type type, BoundKind kind, TypeSymbol tsym, TypeVar bound) {
//            this(type, kind, tsym);
//            this.bound = bound;
//        }
//
//        public boolean isSuperBound() {
//            return kind == SUPER ||
//                kind == UNBOUND;
//        }
//        public boolean isExtendsBound() {
//            return kind == EXTENDS ||
//                kind == UNBOUND;
//        }
//        public boolean isUnbound() {
//            return kind == UNBOUND;
//        }
//
//        public Type withTypeVar(Type t) {
//            //-System.err.println(this+".withTypeVar("+t+");");//DEBUG
//            if (bound == t)
//                return this;
//            bound = (TypeVar)t;
//            return this;
//        }
//
//        boolean isPrintingBound = false;
//        public String toString() {
//            StringBuffer s = new StringBuffer();
//            s.append(kind.toString());
//            if (kind != UNBOUND)
//                s.append(type);
//            if (moreInfo && bound != null && !isPrintingBound)
//                try {
//                    isPrintingBound = true;
//                    s.append("{:").append(bound.bound).append(":}");
//                } finally {
//                    isPrintingBound = false;
//                }
//            return s.toString();
//        }
//
//        public Type map(Mapping f) {
//            //- System.err.println("   (" + this + ").map(" + f + ")");//DEBUG
//            Type t = type;
//            if (t != null)
//                t = f.apply(t);
//            if (t == type)
//                return this;
//            else
//                return new WildcardType(t, kind, tsym, bound);
//        }
//
//        public Type getExtendsBound() {
//            if (kind == EXTENDS)
//                return type;
//            else
//                return null;
//        }
//
//        public Type getSuperBound() {
//            if (kind == SUPER)
//                return type;
//            else
//                return null;
//        }
//
//        public TypeKind getKind() {
//            return TypeKind.WILDCARD;
//        }
//
//        public <R, P> R accept(TypeVisitor<R, P> v, P p) {
//            return v.visitWildcard(this, p);
//        }
//    }
//
//    public static class ClassType extends Type implements DeclaredType {
//
//        /** The enclosing type of this type. If this is the type of an inner
//         *  class, outer_field refers to the type of its enclosing
//         *  instance class, in all other cases it referes to noType.
//         */
//        private Type outer_field;
//
//        /** The type parameters of this type (to be set once class is loaded).
//         */
//        public List<Type> typarams_field;
//
//        /** A cache variable for the type parameters of this type,
//         *  appended to all parameters of its enclosing class.
//         *  @see #allparams
//         */
//        public List<Type> allparams_field;
//
//        /** The supertype of this class (to be set once class is loaded).
//         */
//        public Type supertype_field;
//
//        /** The interfaces of this class (to be set once class is loaded).
//         */
//        public List<Type> interfaces_field;
//
//        public ClassType(Type outer, List<Type> typarams, TypeSymbol tsym) {
//            super(CLASS, tsym);
//            this.outer_field = outer;
//            this.typarams_field = typarams;
//            this.allparams_field = null;
//            this.supertype_field = null;
//            this.interfaces_field = null;
//            /*
//            // this can happen during error recovery
//            assert
//                outer.isParameterized() ?
//                typarams.length() == tsym.type.typarams().length() :
//                outer.isRaw() ?
//                typarams.length() == 0 :
//                true;
//            */
//        }
//
//        @Override
//        public <R,S> R accept(Type.Visitor<R,S> v, S s) {
//            return v.visitClassType(this, s);
//        }
//
//        public Type constType(Object constValue) {
//            final Object value = constValue;
//            return new ClassType(getEnclosingType(), typarams_field, tsym) {
//                    @Override
//                    public Object constValue() {
//                        return value;
//                    }
//                    @Override
//                    public Type baseType() {
//                        return tsym.type;
//                    }
//                };
//        }
//
//        /** The Java source which this type represents.
//         */
//        public String toString() {
//            StringBuffer buf = new StringBuffer();
//            if (getEnclosingType().tag == CLASS && tsym.owner.kind == TYP) {
//                buf.append(getEnclosingType().toString());
//                buf.append(".");
//                buf.append(className(tsym, false));
//            } else {
//                buf.append(className(tsym, true));
//            }
//            if (getTypeArguments().nonEmpty()) {
//                buf.append('<');
//                buf.append(getTypeArguments().toString());
//                buf.append(">");
//            }
//            return buf.toString();
//        }
////where
//            private String className(Symbol sym, boolean longform) {
//                if (sym.name.isEmpty() && (sym.flags() & COMPOUND) != 0) {
//                    StringBuffer s = new StringBuffer(supertype_field.toString());
//                    for (List<Type> is=interfaces_field; is.nonEmpty(); is = is.tail) {
//                        s.append("&");
//                        s.append(is.head.toString());
//                    }
//                    return s.toString();
//                } else if (sym.name.isEmpty()) {
//                    String s;
//                    ClassType norm = (ClassType) tsym.type;
//                    if (norm == null) {
//                        s = Log.getLocalizedString("anonymous.class", (Object)null);
//                    } else if (norm.interfaces_field != null && norm.interfaces_field.nonEmpty()) {
//                        s = Log.getLocalizedString("anonymous.class",
//                                                   norm.interfaces_field.head);
//                    } else {
//                        s = Log.getLocalizedString("anonymous.class",
//                                                   norm.supertype_field);
//                    }
//                    if (moreInfo)
//                        s += String.valueOf(sym.hashCode());
//                    return s;
//                } else if (longform) {
//                    return sym.getQualifiedName().toString();
//                } else {
//                    return sym.name.toString();
//                }
//            }
//
//        public List<Type> getTypeArguments() {
//            if (typarams_field == null) {
//                complete();
//                if (typarams_field == null)
//                    typarams_field = List.nil();
//            }
//            return typarams_field;
//        }
//
//        public boolean hasErasedSupertypes() {
//            return isRaw();
//        }
//
//        public Type getEnclosingType() {
//            return outer_field;
//        }
//
//        public void setEnclosingType(Type outer) {
//            outer_field = outer;
//        }
//
//        public List<Type> allparams() {
//            if (allparams_field == null) {
//                allparams_field = getTypeArguments().prependList(getEnclosingType().allparams());
//            }
//            return allparams_field;
//        }
//
//        public boolean isErroneous() {
//            return
//                getEnclosingType().isErroneous() ||
//                isErroneous(getTypeArguments()) ||
//                this != tsym.type && tsym.type.isErroneous();
//        }
//
//        public boolean isParameterized() {
//            return allparams().tail != null;
//            // optimization, was: allparams().nonEmpty();
//        }
//
//        /** A cache for the rank. */
//        int rank_field = -1;
//
//        /** A class type is raw if it misses some
//         *  of its type parameter sections.
//         *  After validation, this is equivalent to:
//         *  allparams.isEmpty() && tsym.type.allparams.nonEmpty();
//         */
//        public boolean isRaw() {
//            return
//                this != tsym.type && // necessary, but not sufficient condition
//                tsym.type.allparams().nonEmpty() &&
//                allparams().isEmpty();
//        }
//
//        public Type map(Mapping f) {
//            Type outer = getEnclosingType();
//            Type outer1 = f.apply(outer);
//            List<Type> typarams = getTypeArguments();
//            List<Type> typarams1 = map(typarams, f);
//            if (outer1 == outer && typarams1 == typarams) return this;
//            else return new ClassType(outer1, typarams1, tsym);
//        }
//
//        public boolean contains(Type elem) {
//            return
//                elem == this
//                || (isParameterized()
//                    && (getEnclosingType().contains(elem) || contains(getTypeArguments(), elem)));
//        }
//
//        public void complete() {
//            if (tsym.completer != null) tsym.complete();
//        }
//
//        public TypeKind getKind() {
//            return TypeKind.DECLARED;
//        }
//
//        public <R, P> R accept(TypeVisitor<R, P> v, P p) {
//            return v.visitDeclared(this, p);
//        }
//    }
//
//    public static class ErasedClassType extends ClassType {
//        public ErasedClassType(Type outer, TypeSymbol tsym) {
//            super(outer, List.<Type>nil(), tsym);
//        }
//
//        @Override
//        public boolean hasErasedSupertypes() {
//            return true;
//        }
//    }
//
//    public static class ArrayType extends Type
//            implements javax.lang.model.type.ArrayType {
//
//        public Type elemtype;
//
//        public ArrayType(Type elemtype, TypeSymbol arrayClass) {
//            super(ARRAY, arrayClass);
//            this.elemtype = elemtype;
//        }
//
//        @Override
//        public <R,S> R accept(Type.Visitor<R,S> v, S s) {
//            return v.visitArrayType(this, s);
//        }
//
//        public String toString() {
//            return elemtype + "[]";
//        }
//
//        public boolean equals(Object obj) {
//            return
//                this == obj ||
//                (obj instanceof ArrayType &&
//                 this.elemtype.equals(((ArrayType)obj).elemtype));
//        }
//
//        public int hashCode() {
//            return (ARRAY << 5) + elemtype.hashCode();
//        }
//
//        public List<Type> allparams() { return elemtype.allparams(); }
//
//        public boolean isErroneous() {
//            return elemtype.isErroneous();
//        }
//
//        public boolean isParameterized() {
//            return elemtype.isParameterized();
//        }
//
//        public boolean isRaw() {
//            return elemtype.isRaw();
//        }
//
//        public Type map(Mapping f) {
//            Type elemtype1 = f.apply(elemtype);
//            if (elemtype1 == elemtype) return this;
//            else return new ArrayType(elemtype1, tsym);
//        }
//
//        public boolean contains(Type elem) {
//            return elem == this || elemtype.contains(elem);
//        }
//
//        public void complete() {
//            elemtype.complete();
//        }
//
//        public Type getComponentType() {
//            return elemtype;
//        }
//
//        public TypeKind getKind() {
//            return TypeKind.ARRAY;
//        }
//
//        public <R, P> R accept(TypeVisitor<R, P> v, P p) {
//            return v.visitArray(this, p);
//        }
//    }
//
//    public static class MethodType extends Type
//                    implements Cloneable, ExecutableType {
//
//        public List<Type> argtypes;
//        public Type restype;
//        public List<Type> thrown;
//
//        public MethodType(List<Type> argtypes,
//                          Type restype,
//                          List<Type> thrown,
//                          TypeSymbol methodClass) {
//            super(METHOD, methodClass);
//            this.argtypes = argtypes;
//            this.restype = restype;
//            this.thrown = thrown;
//        }
//
//        @Override
//        public <R,S> R accept(Type.Visitor<R,S> v, S s) {
//            return v.visitMethodType(this, s);
//        }
//
//        /** The Java source which this type represents.
//         *
//         *  XXX 06/09/99 iris This isn't correct Java syntax, but it probably
//         *  should be.
//         */
//        public String toString() {
//            return "(" + argtypes + ")" + restype;
//        }
//
//        public boolean equals(Object obj) {
//            if (this == obj)
//                return true;
//            if (!(obj instanceof MethodType))
//                return false;
//            MethodType m = (MethodType)obj;
//            List<Type> args1 = argtypes;
//            List<Type> args2 = m.argtypes;
//            while (!args1.isEmpty() && !args2.isEmpty()) {
//                if (!args1.head.equals(args2.head))
//                    return false;
//                args1 = args1.tail;
//                args2 = args2.tail;
//            }
//            if (!args1.isEmpty() || !args2.isEmpty())
//                return false;
//            return restype.equals(m.restype);
//        }
//
//        public int hashCode() {
//            int h = METHOD;
//            for (List<Type> thisargs = this.argtypes;
//                 thisargs.tail != null; /*inlined: thisargs.nonEmpty()*/
//                 thisargs = thisargs.tail)
//                h = (h << 5) + thisargs.head.hashCode();
//            return (h << 5) + this.restype.hashCode();
//        }
//
//        public List<Type>        getParameterTypes() { return argtypes; }
//        public Type              getReturnType()     { return restype; }
//        public List<Type>        getThrownTypes()    { return thrown; }
//
//        public void setThrown(List<Type> t) {
//            thrown = t;
//        }
//
//        public boolean isErroneous() {
//            return
//                isErroneous(argtypes) ||
//                restype != null && restype.isErroneous();
//        }
//
//        public Type map(Mapping f) {
//            List<Type> argtypes1 = map(argtypes, f);
//            Type restype1 = f.apply(restype);
//            List<Type> thrown1 = map(thrown, f);
//            if (argtypes1 == argtypes &&
//                restype1 == restype &&
//                thrown1 == thrown) return this;
//            else return new MethodType(argtypes1, restype1, thrown1, tsym);
//        }
//
//        public boolean contains(Type elem) {
//            return elem == this || contains(argtypes, elem) || restype.contains(elem);
//        }
//
//        public MethodType asMethodType() { return this; }
//
//        public void complete() {
//            for (List<Type> l = argtypes; l.nonEmpty(); l = l.tail)
//                l.head.complete();
//            restype.complete();
//            for (List<Type> l = thrown; l.nonEmpty(); l = l.tail)
//                l.head.complete();
//        }
//
//        public List<TypeVar> getTypeVariables() {
//            return List.nil();
//        }
//
//        public TypeSymbol asElement() {
//            return null;
//        }
//
//        public TypeKind getKind() {
//            return TypeKind.EXECUTABLE;
//        }
//
//        public <R, P> R accept(TypeVisitor<R, P> v, P p) {
//            return v.visitExecutable(this, p);
//        }
//    }
//
//    public static class PackageType extends Type implements NoType {
//
//        PackageType(TypeSymbol tsym) {
//            super(PACKAGE, tsym);
//        }
//
//        @Override
//        public <R,S> R accept(Type.Visitor<R,S> v, S s) {
//            return v.visitPackageType(this, s);
//        }
//
//        public String toString() {
//            return tsym.getQualifiedName().toString();
//        }
//
//        public TypeKind getKind() {
//            return TypeKind.PACKAGE;
//        }
//
//        public <R, P> R accept(TypeVisitor<R, P> v, P p) {
//            return v.visitNoType(this, p);
//        }
//    }
//
//    public static class TypeVar extends Type implements TypeVariable {
//
//        /** The bound of this type variable; set from outside.
//         *  Must be nonempty once it is set.
//         *  For a bound, `bound' is the bound type itself.
//         *  Multiple bounds are expressed as a single class type which has the
//         *  individual bounds as superclass, respectively interfaces.
//         *  The class type then has as `tsym' a compiler generated class `c',
//         *  which has a flag COMPOUND and whose owner is the type variable
//         *  itself. Furthermore, the erasure_field of the class
//         *  points to the first class or interface bound.
//         */
//        public Type bound = null;
//        public Type lower;
//
//        public TypeVar(Name name, Symbol owner, Type lower) {
//            super(TYPEVAR, null);
//            tsym = new TypeSymbol(0, name, this, owner);
//            this.lower = lower;
//        }
//
//        public TypeVar(TypeSymbol tsym, Type bound, Type lower) {
//            super(TYPEVAR, tsym);
//            this.bound = bound;
//            this.lower = lower;
//        }
//
//        @Override
//        public <R,S> R accept(Type.Visitor<R,S> v, S s) {
//            return v.visitTypeVar(this, s);
//        }
//
//        public Type getUpperBound() { return bound; }
//
//        int rank_field = -1;
//
//        public Type getLowerBound() {
//            return lower;
//        }
//
//        public TypeKind getKind() {
//            return TypeKind.TYPEVAR;
//        }
//
//        public boolean isCaptured() {
//            return false;
//        }
//
//        public <R, P> R accept(TypeVisitor<R, P> v, P p) {
//            return v.visitTypeVariable(this, p);
//        }
//    }
//
//    /** A captured type variable comes from wildcards which can have
//     *  both upper and lower bound.  CapturedType extends TypeVar with
//     *  a lower bound.
//     */
//    public static class CapturedType extends TypeVar {
//
//        public Type lower;
//        public WildcardType wildcard;
//
//        public CapturedType(Name name,
//                            Symbol owner,
//                            Type upper,
//                            Type lower,
//                            WildcardType wildcard) {
//            super(name, owner, lower);
//            assert lower != null;
//            this.bound = upper;
//            this.lower = lower;
//            this.wildcard = wildcard;
//        }
//
//        @Override
//        public <R,S> R accept(Type.Visitor<R,S> v, S s) {
//            return v.visitCapturedType(this, s);
//        }
//
//        public Type getLowerBound() {
//            return lower;
//        }
//
//        @Override
//        public boolean isCaptured() {
//            return true;
//        }
//
//        @Override
//        public String toString() {
//            return "capture#"
//                + (hashCode() & 0xFFFFFFFFL) % PRIME
//                + " of "
//                + wildcard;
//        }
//        static final int PRIME = 997;  // largest prime less than 1000
//    }
//
//    public static abstract class DelegatedType extends Type {
//        public Type qtype;
//        public DelegatedType(int tag, Type qtype) {
//            super(tag, qtype.tsym);
//            this.qtype = qtype;
//        }
//        public String toString() { return qtype.toString(); }
//        public List<Type> getTypeArguments() { return qtype.getTypeArguments(); }
//        public Type getEnclosingType() { return qtype.getEnclosingType(); }
//        public List<Type> getParameterTypes() { return qtype.getParameterTypes(); }
//        public Type getReturnType() { return qtype.getReturnType(); }
//        public List<Type> getThrownTypes() { return qtype.getThrownTypes(); }
//        public List<Type> allparams() { return qtype.allparams(); }
//        public Type getUpperBound() { return qtype.getUpperBound(); }
//        public Object clone() { DelegatedType t = (DelegatedType)super.clone(); t.qtype = (Type)qtype.clone(); return t; }
//        public boolean isErroneous() { return qtype.isErroneous(); }
//    }
//
//    public static class ForAll extends DelegatedType
//            implements Cloneable, ExecutableType {
//        public List<Type> tvars;
//
//        public ForAll(List<Type> tvars, Type qtype) {
//            super(FORALL, qtype);
//            this.tvars = tvars;
//        }
//
//        @Override
//        public <R,S> R accept(Type.Visitor<R,S> v, S s) {
//            return v.visitForAll(this, s);
//        }
//
//        public String toString() {
//            return "<" + tvars + ">" + qtype;
//        }
//
//        public List<Type> getTypeArguments()   { return tvars; }
//
//        public void setThrown(List<Type> t) {
//            qtype.setThrown(t);
//        }
//
//        public Object clone() {
//            ForAll result = (ForAll)super.clone();
//            result.qtype = (Type)result.qtype.clone();
//            return result;
//        }
//
//        public boolean isErroneous()  {
//            return qtype.isErroneous();
//        }
//
//        public Type map(Mapping f) {
//            return f.apply(qtype);
//        }
//
//        public boolean contains(Type elem) {
//            return qtype.contains(elem);
//        }
//
//        public MethodType asMethodType() {
//            return qtype.asMethodType();
//        }
//
//        public void complete() {
//            for (List<Type> l = tvars; l.nonEmpty(); l = l.tail) {
//                ((TypeVar)l.head).bound.complete();
//            }
//            qtype.complete();
//        }
//
//        public List<TypeVar> getTypeVariables() {
//            return List.convert(TypeVar.class, getTypeArguments());
//        }
//
//        public TypeKind getKind() {
//            return TypeKind.EXECUTABLE;
//        }
//
//        public <R, P> R accept(TypeVisitor<R, P> v, P p) {
//            return v.visitExecutable(this, p);
//        }
//    }
//
//    /** A class for instantiatable variables, for use during type
//     *  inference.
//     */
//    public static class UndetVar extends DelegatedType {
//        public List<Type> lobounds = List.nil();
//        public List<Type> hibounds = List.nil();
//        public Type inst = null;
//
//        @Override
//        public <R,S> R accept(Type.Visitor<R,S> v, S s) {
//            return v.visitUndetVar(this, s);
//        }
//
//        public UndetVar(Type origin) {
//            super(UNDETVAR, origin);
//        }
//
//        public String toString() {
//            if (inst != null) return inst.toString();
//            else return qtype + "?";
//        }
//
//        public Type baseType() {
//            if (inst != null) return inst.baseType();
//            else return this;
//        }
//    }
//
//    /** Represents VOID or NONE.
//     */
//    static class JCNoType extends Type implements NoType {
//        public JCNoType(int tag) {
//            super(tag, null);
//        }
//
//        @Override
//        public TypeKind getKind() {
//            switch (tag) {
//            case VOID:  return TypeKind.VOID;
//            case NONE:  return TypeKind.NONE;
//            default:
//                throw new AssertionError("Unexpected tag: " + tag);
//            }
//        }
//
//        @Override
//        public <R, P> R accept(TypeVisitor<R, P> v, P p) {
//            return v.visitNoType(this, p);
//        }
//    }
//
//    static class BottomType extends Type implements NullType {
//        public BottomType() {
//            super(TypeTags.BOT, null);
//        }
//
//        @Override
//        public TypeKind getKind() {
//            return TypeKind.NULL;
//        }
//
//        @Override
//        public <R, P> R accept(TypeVisitor<R, P> v, P p) {
//            return v.visitNull(this, p);
//        }
//
//        @Override
//        public Type constType(Object value) {
//            return this;
//        }
//
//        @Override
//        public String stringValue() {
//            return "null";
//        }
//    }
//
//    public static class ErrorType extends ClassType
//            implements javax.lang.model.type.ErrorType {
//
//        private Type originalType = null;
//
//        public ErrorType(Type originalType, TypeSymbol tsym) {
//            super(noType, List.<Type>nil(), null);
//            tag = ERROR;
//            this.tsym = tsym;
//            this.originalType = (originalType == null ? noType : originalType);
//        }
//
//        public ErrorType(ClassSymbol c, Type originalType) {
//            this(originalType, c);
//            c.type = this;
//            c.kind = ERR;
//            c.members_field = new Scope.ErrorScope(c);
//        }
//
//        public ErrorType(Name name, TypeSymbol container, Type originalType) {
//            this(new ClassSymbol(PUBLIC|STATIC|ACYCLIC, name, null, container), originalType);
//        }
//
//        @Override
//        public <R,S> R accept(Type.Visitor<R,S> v, S s) {
//            return v.visitErrorType(this, s);
//        }
//
//        public Type constType(Object constValue) { return this; }
//        public Type getEnclosingType()          { return this; }
//        public Type getReturnType()              { return this; }
//        public Type asSub(Symbol sym)            { return this; }
//        public Type map(Mapping f)               { return this; }
//
//        public boolean isGenType(Type t)         { return true; }
//        public boolean isErroneous()             { return true; }
//        public boolean isCompound()              { return false; }
//        public boolean isInterface()             { return false; }
//
//        public List<Type> allparams()            { return List.nil(); }
//        public List<Type> getTypeArguments()     { return List.nil(); }
//
//        public TypeKind getKind() {
//            return TypeKind.ERROR;
//        }
//
//        public Type getOriginalType() {
//            return originalType;
//        }
//
//        public <R, P> R accept(TypeVisitor<R, P> v, P p) {
//            return v.visitError(this, p);
//        }
//    }
//
//    /**
//     * A visitor for types.  A visitor is used to implement operations
//     * (or relations) on types.  Most common operations on types are
//     * binary relations and this interface is designed for binary
//     * relations, that is, operations on the form
//     * Type&nbsp;&times;&nbsp;S&nbsp;&rarr;&nbsp;R.
//     * <!-- In plain text: Type x S -> R -->
//     *
//     * @param <R> the return type of the operation implemented by this
//     * visitor; use Void if no return type is needed.
//     * @param <S> the type of the second argument (the first being the
//     * type itself) of the operation implemented by this visitor; use
//     * Void if a second argument is not needed.
//     */
//    public interface Visitor<R,S> {
//        R visitClassType(ClassType t, S s);
//        R visitWildcardType(WildcardType t, S s);
//        R visitArrayType(ArrayType t, S s);
//        R visitMethodType(MethodType t, S s);
//        R visitPackageType(PackageType t, S s);
//        R visitTypeVar(TypeVar t, S s);
//        R visitCapturedType(CapturedType t, S s);
//        R visitForAll(ForAll t, S s);
//        R visitUndetVar(UndetVar t, S s);
//        R visitErrorType(ErrorType t, S s);
//        R visitType(Type t, S s);
//    }
//}
